﻿using ImplementationJeu;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using InterfaceJeu;

namespace TestImplementation
{
    
    
    /// <summary>
    ///Classe de test pour CoordonneesTest, destinée à contenir tous
    ///les tests unitaires CoordonneesTest
    ///</summary>
    [TestClass()]
    public class CoordonneesTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Obtient ou définit le contexte de test qui fournit
        ///des informations sur la série de tests active ainsi que ses fonctionnalités.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Attributs de tests supplémentaires
        // 
        //Vous pouvez utiliser les attributs supplémentaires suivants lorsque vous écrivez vos tests :
        //
        //Utilisez ClassInitialize pour exécuter du code avant d'exécuter le premier test dans la classe
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        [ClassInitialize()]
        public static void MyClassInitialize(TestContext testContext)
        {
            ImplementationJeu.Jeu monJeu = ImplementationJeu.Jeu.Instance;
            InterfaceJeu.Joueur j1 = new ImplementationJeu.Joueur("Nicolas", System.Drawing.Color.Red, "INFO");
            InterfaceJeu.Joueur j2 = new ImplementationJeu.Joueur("Aurelien", System.Drawing.Color.Azure, "EII");
            List<InterfaceJeu.Joueur> lj = new List<InterfaceJeu.Joueur>();
            lj.Add(j1);
            lj.Add(j2);
            monJeu.demarrerNouveuJeu(lj, 100);
        }
        //Utilisez ClassCleanup pour exécuter du code après que tous les tests ont été exécutés dans une classe
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Utilisez TestInitialize pour exécuter du code avant d'exécuter chaque test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Utilisez TestCleanup pour exécuter du code après que chaque test a été exécuté
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///Test pour Constructeur Coordonnees
        ///</summary>
        [TestMethod()]
        public void CoordonneesConstructorTest()
        {
            int i = 453;
            ImplementationJeu.Coordonnees target = new ImplementationJeu.Coordonnees(i);
            int expectedAbs = 53;
            int expectedOrd = 4;
            Assert.AreEqual(expectedAbs, target.abscisse);
            Assert.AreEqual(expectedOrd, target.ordonnee);
        }

        /// <summary>
        ///Test pour Constructeur Coordonnees
        ///</summary>
        [TestMethod()]
        public void CoordonneesConstructorTest1()
        {
            int x = 84;
            int y = 12;
            ImplementationJeu.Coordonnees target = new ImplementationJeu.Coordonnees(x, y);
            Assert.AreEqual(x, target.abscisse);
            Assert.AreEqual(y, target.ordonnee);
        }

        /// <summary>
        ///Test pour Equals
        ///</summary>
        [TestMethod()]
        public void EqualsTest()
        {
            int i = 175;
            ImplementationJeu.Coordonnees target = new ImplementationJeu.Coordonnees(i);
            object obj = new ImplementationJeu.Coordonnees(75,1); 
            bool actual;
            actual = target.Equals(obj);
            Assert.IsTrue(actual);
        }

        /// <summary>
        ///Test pour Equals
        ///</summary>
        [TestMethod()]
        public void EqualsTest2()
        {
            int i = 175;
            ImplementationJeu.Coordonnees target = new ImplementationJeu.Coordonnees(i);
            object obj = null;
            bool actual;
            actual = target.Equals(obj);
            Assert.IsFalse(actual);
        }

        /// <summary>
        ///Test pour GetHashCode
        ///</summary>
        [TestMethod()]
        public void GetHashCodeTest()
        {
            List<int> lesHashCodes = new List<int>();
            int taille = ImplementationJeu.Jeu.Instance.Carte.TailleCote;

            for (int idx = 0; idx < taille * taille; idx++)
            {
                    ImplementationJeu.Coordonnees target = new ImplementationJeu.Coordonnees(idx);
                    int actual = target.GetHashCode();
                    Assert.IsFalse(lesHashCodes.Contains(actual));
                    lesHashCodes.Add(actual);
            }
        }

        /// <summary>
        ///Test pour distance
        ///</summary>
        [TestMethod()]
        public void distanceTest()
        {
            ImplementationJeu.Coordonnees c1 = new ImplementationJeu.Coordonnees(0);
            ImplementationJeu.Coordonnees c2 = new ImplementationJeu.Coordonnees(20,20);
            int expected = 20;
            double actual;
            actual = (int) c1.distance(c2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour distance
        ///</summary>
        [TestMethod()]
        public void distanceTest2()
        {
            ImplementationJeu.Coordonnees c1 = new ImplementationJeu.Coordonnees(15,16);
            ImplementationJeu.Coordonnees c2 = new ImplementationJeu.Coordonnees(15,20);
            int expected = 4;
            double actual;
            actual = (int)c1.distance(c2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour distance
        ///</summary>
        [TestMethod()]
        public void distanceTest3()
        {
            ImplementationJeu.Coordonnees c1 = new ImplementationJeu.Coordonnees(7,19);
            ImplementationJeu.Coordonnees c2 = new ImplementationJeu.Coordonnees(9, 20);
            int expected = 2;
            double actual;
            actual = (int)c1.distance(c2);
            Assert.AreEqual(expected, actual);
        }

        [TestMethod()]
        public void distanceTest4()
        {
            ImplementationJeu.Coordonnees c1 = new ImplementationJeu.Coordonnees(7, 19);
            ImplementationJeu.Coordonnees c2 = new ImplementationJeu.Coordonnees(12, 21);
            int expected = 5;
            double actual;
            actual = (int)c1.distance(c2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour getIndex
        ///</summary>
        [TestMethod()]
        public void getIndexTest()
        {
            ImplementationJeu.Coordonnees target = new ImplementationJeu.Coordonnees(48,23); 
            int expected = 2348;
            int actual;
            actual = target.getIndex();
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour op_Equality
        ///</summary>
        [TestMethod()]
        public void op_EqualityTest()
        {
            ImplementationJeu.Coordonnees c1 = new ImplementationJeu.Coordonnees(48, 23);
            ImplementationJeu.Coordonnees c2 = new ImplementationJeu.Coordonnees(2348); 
            bool expected = true; 
            bool actual;
            actual = (c1 == c2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour op_Inequality
        ///</summary>
        [TestMethod()]
        public void op_InequalityTest()
        {
            ImplementationJeu.Coordonnees c1 = new ImplementationJeu.Coordonnees(48, 23);
            ImplementationJeu.Coordonnees c2 = new ImplementationJeu.Coordonnees(2348); 
            bool expected = false;
            bool actual;
            actual = (c1 != c2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour abscisse
        ///</summary>
        [TestMethod()]
        public void abscisseTest()
        {
            int i = 7584; 
            ImplementationJeu.Coordonnees target = new ImplementationJeu.Coordonnees(i);
            int expected = 84;
            int actual;
            target.abscisse = expected;
            actual = target.abscisse;
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///Test pour ordonnee
        ///</summary>
        [TestMethod()]
        public void ordonneeTest()
        {
            int i = 7584;
            ImplementationJeu.Coordonnees target = new ImplementationJeu.Coordonnees(i);
            int expected = 75;
            int actual;
            target.ordonnee = expected;
            actual = target.ordonnee;
            Assert.AreEqual(expected, actual);
       }


    }
}
